package com.delio.client.produccion.motivos;

import java.util.List;

import com.extjs.gxt.ui.client.data.BaseFilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.BaseListLoader;
import com.extjs.gxt.ui.client.data.BasePagingLoadConfig;
import com.extjs.gxt.ui.client.data.BasePagingLoader;
import com.extjs.gxt.ui.client.data.BeanModel;
import com.extjs.gxt.ui.client.data.BeanModelReader;
import com.extjs.gxt.ui.client.data.FilterPagingLoadConfig;
import com.extjs.gxt.ui.client.data.ListLoadResult;
import com.extjs.gxt.ui.client.data.ListLoader;
import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.data.PagingLoadResult;
import com.extjs.gxt.ui.client.data.PagingLoader;
import com.extjs.gxt.ui.client.data.RpcProxy;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.rpc.AsyncCallback;

public class Motivos{

	private static MotivoServiceAsync ms = GWT.create(MotivoService.class);
	public static PagingLoader<PagingLoadResult<ModelData>> loader;
	public static ListStore<BeanModel> store;
	public static ListStore<BeanModel> storeCombo;
	public static ListLoader<ListLoadResult<ModelData>> loaderCombo;
    public static Integer motivo_id; 
	
public static void getPaginate() {
	RpcProxy<PagingLoadResult<Motivo>> proxy = new RpcProxy<PagingLoadResult<Motivo>>() {

		@Override
		protected void load(Object loadConfig,
		      AsyncCallback<PagingLoadResult<Motivo>> callback) {
			ms.paginateMotivo((FilterPagingLoadConfig) loadConfig, callback);  
		}  
    };
    loader = new BasePagingLoader<PagingLoadResult<ModelData>>(proxy, new BeanModelReader()){  
        @Override  
        protected Object newLoadConfig() {  
          BasePagingLoadConfig config = new BaseFilterPagingLoadConfig();  
          return config;  
        }  
      };  
    loader.setRemoteSort(true);  
    store = new ListStore<BeanModel>(loader);
}

public static void  getStore(){
	
	 RpcProxy<List<Motivo>> proxy = new RpcProxy<List<Motivo>>(){
	    protected void load(Object loadConfig, AsyncCallback<List<Motivo>> callback){
		 ms.LitarMotivo(callback);
		 }
	  	};
	 loaderCombo = new BaseListLoader<ListLoadResult<ModelData>>(proxy, new BeanModelReader());
	 storeCombo = new ListStore<BeanModel>(loaderCombo);
	 loaderCombo.load();

   }



public static void guardar(Motivo m){
	 
	 ms.guardar(m, new AsyncCallback<Boolean>(){

		@Override
		public void onFailure(Throwable caught) {
			MessageBox.alert("Error", "No pudo guardar", null);			
		}

		@Override
		public void onSuccess(Boolean result) {
           if(result){
            MessageBox.alert("Guardado", "Se guardo Correctament", null);
           }else{
        	MessageBox.alert("Error", "No se guardo correctamente", null);
           }
			
		}
	 
	 });
 }	 
 
 public static void actualizar(Motivo m){
	 
	 ms.actualizar(m, new AsyncCallback<Boolean>(){

		@Override
		public void onFailure(Throwable caught) {
			MessageBox.alert("Error", "No pudo actualizar", null);			
		}

		@Override
		public void onSuccess(Boolean result) {
           if(result){
            MessageBox.alert("Actualizado", "Se actualizo Correctament", null);     	   
           }else{
        	MessageBox.alert("Error", "No se actualizo correctamente", null);
           }
		}
	 
	 });
 }
 
 public static void eliminar(int id){
	 ms.eliminar(id, new AsyncCallback<Boolean>(){
		
		 @Override
		 public void onFailure(Throwable caught){
			 MessageBox.alert("Error", "Error en la Eliminacion", null);
		 }
		 
		 public void onSuccess(Boolean result){
			 if(result){
			   MessageBox.alert("Eliminado","Se elimino Correctamente", null); 
			 }else{
			   MessageBox.alert("Error", "No se elimino Correctamente", null);	 
			 } 
		 }

	 });
 }

}